/**
 * (C)2012 Exlu Corporation. All rights reserved.
 * 注意事項   :
 */
package cn.exlu.wea.field.validator.effective;


/**
 * 数值有效性判定类
 * @author Mark 
 * @version 1.0.1.1
 * @CreateTime 2012-12-10
 */
public final class LpEffectiveDigitalUtil {

    /**
     * 数值最大判定
     * 判定方式：
     * @param str 输入字段
     * @param max 最大值
     * @return true：是 false: 否
     */
    public static boolean isMaxRangeValue(String str, String max) {
        // 带符号的零比较
        if(isAllZero(str,max)){
            return true;
        }
        boolean isAllNegative=false;
        // 判定两个数值是否都为负数
        if(str.startsWith("-")&&max.startsWith("-")){
            isAllNegative=true;
        }else if(str.startsWith("-")){
            return true;
        }else if(max.startsWith("-")){
            return false;
        }
        // 若是同符号
        // 删除【+】【-】符号位
        String srcStr=str.replaceFirst("[+|-]", "");
        String maxStr=max.replaceFirst("[+|-]", "");
        String[] srcArr=srcStr.split("[.]");
        String[] maxArr=maxStr.split("[.]");
        // 先进行整数部分判定
        // 若长度不相等，长度长的则绝对值一定大
        int compareLen=srcArr[0].length()-maxArr[0].length();
        if(compareLen!=0){
            if (!isAllNegative) {
                return compareLen < 0;
            } else {
                return compareLen > 0;
            }
        }else{
            // 若长度相等，则进行每个字符匹配
            // 若整数部分绝对值不相等
            int compareValue=srcArr[0].compareTo(maxArr[0]);
            if (compareValue != 0) {
                if (!isAllNegative) {
                    return compareValue < 0;
                } else {
                    return compareValue > 0;
                }
            }else{
                // 若整数部分绝对值相等，比较小数部分
                // 初始化小数部分值
                String srcFracValue="";
                String maxFracValue="";
                if(srcArr.length>1){
                    srcFracValue=deleteSuffixZero(srcArr[1]);
                }
                if(maxArr.length>1){
                    maxFracValue=deleteSuffixZero(maxArr[1]);
                }
                if(!isAllNegative){
                    return srcFracValue.compareTo(maxFracValue)<=0;
                }else{
                    return srcFracValue.compareTo(maxFracValue)>=0;
                }
                
            }
        }

    }

    /**
     * 数值最大判定
     * 判定方式：
     * @param str 输入字段
     * @param max 最大值
     * @return true：是 false: 否
     */
    public static boolean isMaxRangeValue(String str, int max) {
       String convStr=str.replaceFirst("[+]", "");
        return Integer.valueOf(convStr) <= max;
    }

    /**
     * 数值最小判定
     * 判定方式：
     * @param str 输入字段
     * @param min 最小值
     * @return true：是 false: 否
     */
    public static boolean isMinRangeValue(String str, String min) {

        return isMaxRangeValue(min,str);
    }
    
    /**
     * 数值最小判定
     * 判定方式：
     * @param str 输入字段
     * @param min 最小值
     * @return true：是 false: 否
     */
    public static boolean isMinRangeValue(String str, int min) {
        String convStr=str.replaceFirst("[+]", "");
        return Integer.valueOf(convStr)>=min;
    }

    /**
     * 数值相等判定
     * 判定方式：
     * @param str 输入字段
     * @param eq 对等值
     * @return true：是 false: 否
     */
    public static boolean isEqualsValue(String str, String eq) {
        // 带符号的零比较
        if(isAllZero(str,eq)){
            return true;
        }
        // 删除【+】符号
        String srcStr=str.replaceFirst("[+]", "");
        String eqStr=eq.replaceFirst("[+]", "");
        String[] srcArr=srcStr.split("[.]");
        String[] eqArr=eqStr.split("[.]");
        String srcFracValue="";
        String eqFracValue="";
        if(srcArr.length>1){
            srcFracValue=deleteSuffixZero(srcArr[1]);
        }
        if(eqArr.length>1){
            eqFracValue=deleteSuffixZero(eqArr[1]);
        }
        srcStr=srcArr[0]+srcFracValue;
        eqStr=eqArr[0]+eqFracValue;
        return srcStr.equals(eqStr);
    }

    /**
     * 数值相等判定
     * 判定方式：
     * @param str 输入字段
     * @param eq 对等值
     * @return true：是 false: 否
     */
    public static boolean isEqualsValue(String str, int eq) {
        String convStr=str.replaceFirst("[+]", "");
        return Integer.valueOf(convStr)==eq;
    }
    
    /**
     * 整数部分最大长度判定
     * 判定方式：整数部分长度不得超过指定长度
     * @param str 输入字段
     * @param max 最大长度
     * @return true：是 false: 否
     */
    public static boolean isMaxRangeLenthIntPart(String str,int max){
        // 删除【+】【-】符号位
        String srcStr=str.replaceFirst("[+|-]", "");
        char[] chr=srcStr.toCharArray();
        int i=0;
        char pot='.';
        for(char c:chr){
            if(pot==c){
                break;
            }
            i++;
        }
        return i<=max;
    }
    
    /**
     * 小数部分最大长度判定
     * 判定方式：小数部分长度不得超过指定长度
     * @param str 输入字段
     * @param max 最大长度
     * @return true：是 false: 否
     */
    public static boolean isMaxRangeLengthFracPart(String str , int max){
        char[] chr=str.toCharArray();
        int i=chr.length-1;
        int j=0;
        char pot='.';
        for(;i>0;i--){
            if(pot==chr[i]){
                break;
            }
            j++;
        }
        return j<=max;
    }
    
    /**
     * 整数部分、小数部分最大长度判定
     * @param str 输入字段
     * @param igt 整数部分最大长度
     * @param frac 小数部分最大长度
     * @return true：是 false: 否
     */
    public static boolean isMaxRangeLengthDigital(String str,int igt,int frac){
        // 删除【+】【-】符号位
        String srcStr=str.replaceFirst("[+|-]", "");
        char[] chr=srcStr.toCharArray();
        int i=0; // 整数部分长度
        int j=0; // 整数部分加小数点长度
        char pot='.';
        for(char c:chr){
            j++;
            if(pot==c){
                break;
            }
            i++;
        }
        return i<=igt&&chr.length-j<=frac;
    }

    /**
     * 删除小数部分多余的零
     * @param frac 小数部分值
     * @return 被删除后的小数部分值
     */
    private static String deleteSuffixZero(String frac){
        int zeroIndex=frac.length();
        char[] fracArr=frac.toCharArray();
        for(int i=frac.length()-1;i>=0;i--){
            if(fracArr[i]=='0'){
                zeroIndex=i;
            }else{
                break;
            }
        }
        return frac.substring(0,zeroIndex);
    }
    
    /**
     * 两个数都为零的判定
     * 带符号的判定
     * @param str1
     * @param str2
     * @return
     */
    private static boolean isAllZero(String str1,String str2){
        String regZero="^[+|-]?[0]*[.]?[0]*$";
        if(str1.matches(regZero)&&str2.matches(regZero)){
            return true;
        }
        return false;
    }
}
